/*
 * Copyright Codeplay Software Ltd.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use these files except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

// DO NOT MODIFY BY HAND
// This file was automatically generated by generate_pooling_tests.py.
// Results calculated using Tensorflow v1.12.0.

#include <gtest/gtest.h>

#include "sycldnn/padding_mode.h"

#include "sycldnn/pooling/operators.h"

#include "test/types/cartesian_product.h"
#include "test/types/kernel_data_types.h"
#include "test/types/test_backend_types.h"
#include "test/types/to_gtest_types.h"

#include "test/pooling/pooling_fixture.h"

#include <array>
#include <vector>

using namespace sycldnn;  // NOLINT(google-build-using-namespace)
using DataTypeList = sycldnn::types::KernelDataTypes;
using Backends = sycldnn::types::DefaultBackendTypes;

using SNNTypePairs =
    sycldnn::types::CartesianProduct<DataTypeList, Backends>::type;
using GTestTypePairs = sycldnn::types::ToGTestTypes<SNNTypePairs>::type;

template <typename Pair>
using MaxWindow3Stride1Forward =
    PoolingFixture<typename Pair::FirstType, typename Pair::SecondType,
                   pooling::Max, pooling::Forward>;
TYPED_TEST_SUITE(MaxWindow3Stride1Forward, GTestTypePairs);
TYPED_TEST(MaxWindow3Stride1Forward, SAME1x4x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {6.,  7.,  8.,  8.,  10., 11.,
                                         12., 12., 14., 15., 16., 16.,
                                         14., 15., 16., 16.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<3, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow3Stride1Forward, VALID1x4x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {11., 12., 15., 16.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<3, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow3Stride1Forward, SAME1x4x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      11., 12., 13., 14., 15., 16., 15., 16., 19., 20., 21.,
      22., 23., 24., 23., 24., 27., 28., 29., 30., 31., 32.,
      31., 32., 27., 28., 29., 30., 31., 32., 31., 32.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<3, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow3Stride1Forward, VALID1x4x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {21., 22., 23., 24.,
                                         29., 30., 31., 32.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<3, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow3Stride1Forward, SAME1x4x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      21., 22., 23., 24., 25., 26., 27., 28., 29., 30., 31., 32., 29.,
      30., 31., 32., 37., 38., 39., 40., 41., 42., 43., 44., 45., 46.,
      47., 48., 45., 46., 47., 48., 53., 54., 55., 56., 57., 58., 59.,
      60., 61., 62., 63., 64., 61., 62., 63., 64., 53., 54., 55., 56.,
      57., 58., 59., 60., 61., 62., 63., 64., 61., 62., 63., 64.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<3, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow3Stride1Forward, VALID1x4x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {41., 42., 43., 44., 45., 46.,
                                         47., 48., 57., 58., 59., 60.,
                                         61., 62., 63., 64.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<3, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow3Stride1Forward, SAME1x4x5x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {7.,  8.,  9.,  10., 10., 12., 13.,
                                         14., 15., 15., 17., 18., 19., 20.,
                                         20., 17., 18., 19., 20., 20.};
  const std::array<int, 4> in_shape = {{1, 4, 5, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<3, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow3Stride1Forward, VALID1x4x5x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {13., 14., 15., 18., 19., 20.};
  const std::array<int, 4> in_shape = {{1, 4, 5, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<3, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow3Stride1Forward, SAME1x4x5x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      13., 14., 15., 16., 17., 18., 19., 20., 19., 20., 23., 24., 25., 26.,
      27., 28., 29., 30., 29., 30., 33., 34., 35., 36., 37., 38., 39., 40.,
      39., 40., 33., 34., 35., 36., 37., 38., 39., 40., 39., 40.};
  const std::array<int, 4> in_shape = {{1, 4, 5, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<3, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow3Stride1Forward, VALID1x4x5x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {25., 26., 27., 28., 29., 30.,
                                         35., 36., 37., 38., 39., 40.};
  const std::array<int, 4> in_shape = {{1, 4, 5, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<3, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow3Stride1Forward, SAME1x4x5x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      25., 26., 27., 28., 29., 30., 31., 32., 33., 34., 35., 36., 37., 38.,
      39., 40., 37., 38., 39., 40., 45., 46., 47., 48., 49., 50., 51., 52.,
      53., 54., 55., 56., 57., 58., 59., 60., 57., 58., 59., 60., 65., 66.,
      67., 68., 69., 70., 71., 72., 73., 74., 75., 76., 77., 78., 79., 80.,
      77., 78., 79., 80., 65., 66., 67., 68., 69., 70., 71., 72., 73., 74.,
      75., 76., 77., 78., 79., 80., 77., 78., 79., 80.};
  const std::array<int, 4> in_shape = {{1, 4, 5, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<3, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow3Stride1Forward, VALID1x4x5x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      49., 50., 51., 52., 53., 54., 55., 56., 57., 58., 59., 60.,
      69., 70., 71., 72., 73., 74., 75., 76., 77., 78., 79., 80.};
  const std::array<int, 4> in_shape = {{1, 4, 5, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<3, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow3Stride1Forward, SAME1x4x6x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      8.,  9.,  10., 11., 12., 12., 14., 15., 16., 17., 18., 18.,
      20., 21., 22., 23., 24., 24., 20., 21., 22., 23., 24., 24.};
  const std::array<int, 4> in_shape = {{1, 4, 6, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<3, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow3Stride1Forward, VALID1x4x6x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {15., 16., 17., 18.,
                                         21., 22., 23., 24.};
  const std::array<int, 4> in_shape = {{1, 4, 6, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<3, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow3Stride1Forward, SAME1x4x6x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      15., 16., 17., 18., 19., 20., 21., 22., 23., 24., 23., 24.,
      27., 28., 29., 30., 31., 32., 33., 34., 35., 36., 35., 36.,
      39., 40., 41., 42., 43., 44., 45., 46., 47., 48., 47., 48.,
      39., 40., 41., 42., 43., 44., 45., 46., 47., 48., 47., 48.};
  const std::array<int, 4> in_shape = {{1, 4, 6, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<3, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow3Stride1Forward, VALID1x4x6x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {29., 30., 31., 32., 33., 34.,
                                         35., 36., 41., 42., 43., 44.,
                                         45., 46., 47., 48.};
  const std::array<int, 4> in_shape = {{1, 4, 6, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<3, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow3Stride1Forward, SAME1x4x6x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      29., 30., 31., 32., 33., 34., 35., 36., 37., 38., 39., 40., 41., 42.,
      43., 44., 45., 46., 47., 48., 45., 46., 47., 48., 53., 54., 55., 56.,
      57., 58., 59., 60., 61., 62., 63., 64., 65., 66., 67., 68., 69., 70.,
      71., 72., 69., 70., 71., 72., 77., 78., 79., 80., 81., 82., 83., 84.,
      85., 86., 87., 88., 89., 90., 91., 92., 93., 94., 95., 96., 93., 94.,
      95., 96., 77., 78., 79., 80., 81., 82., 83., 84., 85., 86., 87., 88.,
      89., 90., 91., 92., 93., 94., 95., 96., 93., 94., 95., 96.};
  const std::array<int, 4> in_shape = {{1, 4, 6, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<3, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow3Stride1Forward, VALID1x4x6x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      57., 58., 59., 60., 61., 62., 63., 64., 65., 66., 67.,
      68., 69., 70., 71., 72., 81., 82., 83., 84., 85., 86.,
      87., 88., 89., 90., 91., 92., 93., 94., 95., 96.};
  const std::array<int, 4> in_shape = {{1, 4, 6, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<3, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow3Stride1Forward, SAME1x5x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {6.,  7.,  8.,  8.,  10., 11., 12.,
                                         12., 14., 15., 16., 16., 18., 19.,
                                         20., 20., 18., 19., 20., 20.};
  const std::array<int, 4> in_shape = {{1, 5, 4, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<3, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow3Stride1Forward, VALID1x5x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {11., 12., 15., 16., 19., 20.};
  const std::array<int, 4> in_shape = {{1, 5, 4, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<3, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow3Stride1Forward, SAME1x5x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      11., 12., 13., 14., 15., 16., 15., 16., 19., 20., 21., 22., 23., 24.,
      23., 24., 27., 28., 29., 30., 31., 32., 31., 32., 35., 36., 37., 38.,
      39., 40., 39., 40., 35., 36., 37., 38., 39., 40., 39., 40.};
  const std::array<int, 4> in_shape = {{1, 5, 4, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<3, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow3Stride1Forward, VALID1x5x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {21., 22., 23., 24., 29., 30.,
                                         31., 32., 37., 38., 39., 40.};
  const std::array<int, 4> in_shape = {{1, 5, 4, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<3, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow3Stride1Forward, SAME1x5x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      21., 22., 23., 24., 25., 26., 27., 28., 29., 30., 31., 32., 29., 30.,
      31., 32., 37., 38., 39., 40., 41., 42., 43., 44., 45., 46., 47., 48.,
      45., 46., 47., 48., 53., 54., 55., 56., 57., 58., 59., 60., 61., 62.,
      63., 64., 61., 62., 63., 64., 69., 70., 71., 72., 73., 74., 75., 76.,
      77., 78., 79., 80., 77., 78., 79., 80., 69., 70., 71., 72., 73., 74.,
      75., 76., 77., 78., 79., 80., 77., 78., 79., 80.};
  const std::array<int, 4> in_shape = {{1, 5, 4, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<3, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow3Stride1Forward, VALID1x5x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      41., 42., 43., 44., 45., 46., 47., 48., 57., 58., 59., 60.,
      61., 62., 63., 64., 73., 74., 75., 76., 77., 78., 79., 80.};
  const std::array<int, 4> in_shape = {{1, 5, 4, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<3, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow3Stride1Forward, SAME1x5x5x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      7.,  8.,  9.,  10., 10., 12., 13., 14., 15., 15., 17., 18., 19.,
      20., 20., 22., 23., 24., 25., 25., 22., 23., 24., 25., 25.};
  const std::array<int, 4> in_shape = {{1, 5, 5, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<3, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow3Stride1Forward, VALID1x5x5x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {13., 14., 15., 18., 19.,
                                         20., 23., 24., 25.};
  const std::array<int, 4> in_shape = {{1, 5, 5, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<3, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow3Stride1Forward, SAME1x5x5x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      13., 14., 15., 16., 17., 18., 19., 20., 19., 20., 23., 24., 25.,
      26., 27., 28., 29., 30., 29., 30., 33., 34., 35., 36., 37., 38.,
      39., 40., 39., 40., 43., 44., 45., 46., 47., 48., 49., 50., 49.,
      50., 43., 44., 45., 46., 47., 48., 49., 50., 49., 50.};
  const std::array<int, 4> in_shape = {{1, 5, 5, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<3, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow3Stride1Forward, VALID1x5x5x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {25., 26., 27., 28., 29., 30.,
                                         35., 36., 37., 38., 39., 40.,
                                         45., 46., 47., 48., 49., 50.};
  const std::array<int, 4> in_shape = {{1, 5, 5, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<3, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow3Stride1Forward, SAME1x5x5x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      25., 26.,  27., 28., 29.,  30., 31., 32., 33., 34., 35.,  36., 37.,
      38., 39.,  40., 37., 38.,  39., 40., 45., 46., 47., 48.,  49., 50.,
      51., 52.,  53., 54., 55.,  56., 57., 58., 59., 60., 57.,  58., 59.,
      60., 65.,  66., 67., 68.,  69., 70., 71., 72., 73., 74.,  75., 76.,
      77., 78.,  79., 80., 77.,  78., 79., 80., 85., 86., 87.,  88., 89.,
      90., 91.,  92., 93., 94.,  95., 96., 97., 98., 99., 100., 97., 98.,
      99., 100., 85., 86., 87.,  88., 89., 90., 91., 92., 93.,  94., 95.,
      96., 97.,  98., 99., 100., 97., 98., 99., 100.};
  const std::array<int, 4> in_shape = {{1, 5, 5, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<3, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow3Stride1Forward, VALID1x5x5x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      49., 50., 51., 52., 53., 54., 55., 56., 57., 58., 59., 60.,
      69., 70., 71., 72., 73., 74., 75., 76., 77., 78., 79., 80.,
      89., 90., 91., 92., 93., 94., 95., 96., 97., 98., 99., 100.};
  const std::array<int, 4> in_shape = {{1, 5, 5, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<3, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow3Stride1Forward, SAME1x5x6x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {8.,  9.,  10., 11., 12., 12., 14., 15.,
                                         16., 17., 18., 18., 20., 21., 22., 23.,
                                         24., 24., 26., 27., 28., 29., 30., 30.,
                                         26., 27., 28., 29., 30., 30.};
  const std::array<int, 4> in_shape = {{1, 5, 6, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<3, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow3Stride1Forward, VALID1x5x6x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {15., 16., 17., 18., 21., 22.,
                                         23., 24., 27., 28., 29., 30.};
  const std::array<int, 4> in_shape = {{1, 5, 6, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<3, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow3Stride1Forward, SAME1x5x6x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      15., 16., 17., 18., 19., 20., 21., 22., 23., 24., 23., 24.,
      27., 28., 29., 30., 31., 32., 33., 34., 35., 36., 35., 36.,
      39., 40., 41., 42., 43., 44., 45., 46., 47., 48., 47., 48.,
      51., 52., 53., 54., 55., 56., 57., 58., 59., 60., 59., 60.,
      51., 52., 53., 54., 55., 56., 57., 58., 59., 60., 59., 60.};
  const std::array<int, 4> in_shape = {{1, 5, 6, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<3, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow3Stride1Forward, VALID1x5x6x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      29., 30., 31., 32., 33., 34., 35., 36., 41., 42., 43., 44.,
      45., 46., 47., 48., 53., 54., 55., 56., 57., 58., 59., 60.};
  const std::array<int, 4> in_shape = {{1, 5, 6, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<3, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow3Stride1Forward, SAME1x5x6x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      29.,  30.,  31.,  32.,  33.,  34.,  35.,  36.,  37.,  38.,  39.,  40.,
      41.,  42.,  43.,  44.,  45.,  46.,  47.,  48.,  45.,  46.,  47.,  48.,
      53.,  54.,  55.,  56.,  57.,  58.,  59.,  60.,  61.,  62.,  63.,  64.,
      65.,  66.,  67.,  68.,  69.,  70.,  71.,  72.,  69.,  70.,  71.,  72.,
      77.,  78.,  79.,  80.,  81.,  82.,  83.,  84.,  85.,  86.,  87.,  88.,
      89.,  90.,  91.,  92.,  93.,  94.,  95.,  96.,  93.,  94.,  95.,  96.,
      101., 102., 103., 104., 105., 106., 107., 108., 109., 110., 111., 112.,
      113., 114., 115., 116., 117., 118., 119., 120., 117., 118., 119., 120.,
      101., 102., 103., 104., 105., 106., 107., 108., 109., 110., 111., 112.,
      113., 114., 115., 116., 117., 118., 119., 120., 117., 118., 119., 120.};
  const std::array<int, 4> in_shape = {{1, 5, 6, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<3, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow3Stride1Forward, VALID1x5x6x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      57.,  58.,  59.,  60.,  61.,  62.,  63.,  64.,  65.,  66.,  67.,  68.,
      69.,  70.,  71.,  72.,  81.,  82.,  83.,  84.,  85.,  86.,  87.,  88.,
      89.,  90.,  91.,  92.,  93.,  94.,  95.,  96.,  105., 106., 107., 108.,
      109., 110., 111., 112., 113., 114., 115., 116., 117., 118., 119., 120.};
  const std::array<int, 4> in_shape = {{1, 5, 6, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<3, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow3Stride1Forward, SAME1x6x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      6.,  7.,  8.,  8.,  10., 11., 12., 12., 14., 15., 16., 16.,
      18., 19., 20., 20., 22., 23., 24., 24., 22., 23., 24., 24.};
  const std::array<int, 4> in_shape = {{1, 6, 4, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<3, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow3Stride1Forward, VALID1x6x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {11., 12., 15., 16.,
                                         19., 20., 23., 24.};
  const std::array<int, 4> in_shape = {{1, 6, 4, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<3, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow3Stride1Forward, SAME1x6x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      11., 12., 13., 14., 15., 16., 15., 16., 19., 20., 21., 22.,
      23., 24., 23., 24., 27., 28., 29., 30., 31., 32., 31., 32.,
      35., 36., 37., 38., 39., 40., 39., 40., 43., 44., 45., 46.,
      47., 48., 47., 48., 43., 44., 45., 46., 47., 48., 47., 48.};
  const std::array<int, 4> in_shape = {{1, 6, 4, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<3, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow3Stride1Forward, VALID1x6x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {21., 22., 23., 24., 29., 30.,
                                         31., 32., 37., 38., 39., 40.,
                                         45., 46., 47., 48.};
  const std::array<int, 4> in_shape = {{1, 6, 4, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<3, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow3Stride1Forward, SAME1x6x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      21., 22., 23., 24., 25., 26., 27., 28., 29., 30., 31., 32., 29., 30.,
      31., 32., 37., 38., 39., 40., 41., 42., 43., 44., 45., 46., 47., 48.,
      45., 46., 47., 48., 53., 54., 55., 56., 57., 58., 59., 60., 61., 62.,
      63., 64., 61., 62., 63., 64., 69., 70., 71., 72., 73., 74., 75., 76.,
      77., 78., 79., 80., 77., 78., 79., 80., 85., 86., 87., 88., 89., 90.,
      91., 92., 93., 94., 95., 96., 93., 94., 95., 96., 85., 86., 87., 88.,
      89., 90., 91., 92., 93., 94., 95., 96., 93., 94., 95., 96.};
  const std::array<int, 4> in_shape = {{1, 6, 4, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<3, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow3Stride1Forward, VALID1x6x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      41., 42., 43., 44., 45., 46., 47., 48., 57., 58., 59.,
      60., 61., 62., 63., 64., 73., 74., 75., 76., 77., 78.,
      79., 80., 89., 90., 91., 92., 93., 94., 95., 96.};
  const std::array<int, 4> in_shape = {{1, 6, 4, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<3, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow3Stride1Forward, SAME1x6x5x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {7.,  8.,  9.,  10., 10., 12., 13., 14.,
                                         15., 15., 17., 18., 19., 20., 20., 22.,
                                         23., 24., 25., 25., 27., 28., 29., 30.,
                                         30., 27., 28., 29., 30., 30.};
  const std::array<int, 4> in_shape = {{1, 6, 5, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<3, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow3Stride1Forward, VALID1x6x5x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {13., 14., 15., 18., 19., 20.,
                                         23., 24., 25., 28., 29., 30.};
  const std::array<int, 4> in_shape = {{1, 6, 5, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<3, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow3Stride1Forward, SAME1x6x5x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      13., 14., 15., 16., 17., 18., 19., 20., 19., 20., 23., 24.,
      25., 26., 27., 28., 29., 30., 29., 30., 33., 34., 35., 36.,
      37., 38., 39., 40., 39., 40., 43., 44., 45., 46., 47., 48.,
      49., 50., 49., 50., 53., 54., 55., 56., 57., 58., 59., 60.,
      59., 60., 53., 54., 55., 56., 57., 58., 59., 60., 59., 60.};
  const std::array<int, 4> in_shape = {{1, 6, 5, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<3, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow3Stride1Forward, VALID1x6x5x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      25., 26., 27., 28., 29., 30., 35., 36., 37., 38., 39., 40.,
      45., 46., 47., 48., 49., 50., 55., 56., 57., 58., 59., 60.};
  const std::array<int, 4> in_shape = {{1, 6, 5, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<3, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow3Stride1Forward, SAME1x6x5x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      25.,  26.,  27.,  28.,  29.,  30.,  31.,  32.,  33.,  34.,  35.,  36.,
      37.,  38.,  39.,  40.,  37.,  38.,  39.,  40.,  45.,  46.,  47.,  48.,
      49.,  50.,  51.,  52.,  53.,  54.,  55.,  56.,  57.,  58.,  59.,  60.,
      57.,  58.,  59.,  60.,  65.,  66.,  67.,  68.,  69.,  70.,  71.,  72.,
      73.,  74.,  75.,  76.,  77.,  78.,  79.,  80.,  77.,  78.,  79.,  80.,
      85.,  86.,  87.,  88.,  89.,  90.,  91.,  92.,  93.,  94.,  95.,  96.,
      97.,  98.,  99.,  100., 97.,  98.,  99.,  100., 105., 106., 107., 108.,
      109., 110., 111., 112., 113., 114., 115., 116., 117., 118., 119., 120.,
      117., 118., 119., 120., 105., 106., 107., 108., 109., 110., 111., 112.,
      113., 114., 115., 116., 117., 118., 119., 120., 117., 118., 119., 120.};
  const std::array<int, 4> in_shape = {{1, 6, 5, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<3, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow3Stride1Forward, VALID1x6x5x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      49.,  50.,  51.,  52.,  53.,  54.,  55.,  56.,  57.,  58.,  59.,  60.,
      69.,  70.,  71.,  72.,  73.,  74.,  75.,  76.,  77.,  78.,  79.,  80.,
      89.,  90.,  91.,  92.,  93.,  94.,  95.,  96.,  97.,  98.,  99.,  100.,
      109., 110., 111., 112., 113., 114., 115., 116., 117., 118., 119., 120.};
  const std::array<int, 4> in_shape = {{1, 6, 5, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<3, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow3Stride1Forward, SAME1x6x6x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      8.,  9.,  10., 11., 12., 12., 14., 15., 16., 17., 18., 18.,
      20., 21., 22., 23., 24., 24., 26., 27., 28., 29., 30., 30.,
      32., 33., 34., 35., 36., 36., 32., 33., 34., 35., 36., 36.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<3, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow3Stride1Forward, VALID1x6x6x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {15., 16., 17., 18., 21., 22.,
                                         23., 24., 27., 28., 29., 30.,
                                         33., 34., 35., 36.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<3, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow3Stride1Forward, SAME1x6x6x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      15., 16., 17., 18., 19., 20., 21., 22., 23., 24., 23., 24., 27., 28., 29.,
      30., 31., 32., 33., 34., 35., 36., 35., 36., 39., 40., 41., 42., 43., 44.,
      45., 46., 47., 48., 47., 48., 51., 52., 53., 54., 55., 56., 57., 58., 59.,
      60., 59., 60., 63., 64., 65., 66., 67., 68., 69., 70., 71., 72., 71., 72.,
      63., 64., 65., 66., 67., 68., 69., 70., 71., 72., 71., 72.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<3, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow3Stride1Forward, VALID1x6x6x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      29., 30., 31., 32., 33., 34., 35., 36., 41., 42., 43.,
      44., 45., 46., 47., 48., 53., 54., 55., 56., 57., 58.,
      59., 60., 65., 66., 67., 68., 69., 70., 71., 72.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<3, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow3Stride1Forward, SAME1x6x6x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      29.,  30.,  31.,  32.,  33.,  34.,  35.,  36.,  37.,  38.,  39.,  40.,
      41.,  42.,  43.,  44.,  45.,  46.,  47.,  48.,  45.,  46.,  47.,  48.,
      53.,  54.,  55.,  56.,  57.,  58.,  59.,  60.,  61.,  62.,  63.,  64.,
      65.,  66.,  67.,  68.,  69.,  70.,  71.,  72.,  69.,  70.,  71.,  72.,
      77.,  78.,  79.,  80.,  81.,  82.,  83.,  84.,  85.,  86.,  87.,  88.,
      89.,  90.,  91.,  92.,  93.,  94.,  95.,  96.,  93.,  94.,  95.,  96.,
      101., 102., 103., 104., 105., 106., 107., 108., 109., 110., 111., 112.,
      113., 114., 115., 116., 117., 118., 119., 120., 117., 118., 119., 120.,
      125., 126., 127., 128., 129., 130., 131., 132., 133., 134., 135., 136.,
      137., 138., 139., 140., 141., 142., 143., 144., 141., 142., 143., 144.,
      125., 126., 127., 128., 129., 130., 131., 132., 133., 134., 135., 136.,
      137., 138., 139., 140., 141., 142., 143., 144., 141., 142., 143., 144.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<3, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow3Stride1Forward, VALID1x6x6x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      57.,  58.,  59.,  60.,  61.,  62.,  63.,  64.,  65.,  66.,  67.,
      68.,  69.,  70.,  71.,  72.,  81.,  82.,  83.,  84.,  85.,  86.,
      87.,  88.,  89.,  90.,  91.,  92.,  93.,  94.,  95.,  96.,  105.,
      106., 107., 108., 109., 110., 111., 112., 113., 114., 115., 116.,
      117., 118., 119., 120., 129., 130., 131., 132., 133., 134., 135.,
      136., 137., 138., 139., 140., 141., 142., 143., 144.};
  const std::array<int, 4> in_shape = {{1, 6, 6, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<3, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow3Stride1Forward, SAME3x4x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      6.,  7.,  8.,  8.,  10., 11., 12., 12., 14., 15., 16., 16.,
      14., 15., 16., 16., 22., 23., 24., 24., 26., 27., 28., 28.,
      30., 31., 32., 32., 30., 31., 32., 32., 38., 39., 40., 40.,
      42., 43., 44., 44., 46., 47., 48., 48., 46., 47., 48., 48.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<3, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow3Stride1Forward, VALID3x4x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {11., 12., 15., 16., 27., 28.,
                                         31., 32., 43., 44., 47., 48.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<3, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow3Stride1Forward, SAME3x4x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      11., 12., 13., 14., 15., 16., 15., 16., 19., 20., 21., 22., 23., 24.,
      23., 24., 27., 28., 29., 30., 31., 32., 31., 32., 27., 28., 29., 30.,
      31., 32., 31., 32., 43., 44., 45., 46., 47., 48., 47., 48., 51., 52.,
      53., 54., 55., 56., 55., 56., 59., 60., 61., 62., 63., 64., 63., 64.,
      59., 60., 61., 62., 63., 64., 63., 64., 75., 76., 77., 78., 79., 80.,
      79., 80., 83., 84., 85., 86., 87., 88., 87., 88., 91., 92., 93., 94.,
      95., 96., 95., 96., 91., 92., 93., 94., 95., 96., 95., 96.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<3, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow3Stride1Forward, VALID3x4x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      21., 22., 23., 24., 29., 30., 31., 32., 53., 54., 55., 56.,
      61., 62., 63., 64., 85., 86., 87., 88., 93., 94., 95., 96.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<3, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow3Stride1Forward, SAME3x4x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      21.,  22.,  23.,  24.,  25.,  26.,  27.,  28.,  29.,  30.,  31.,  32.,
      29.,  30.,  31.,  32.,  37.,  38.,  39.,  40.,  41.,  42.,  43.,  44.,
      45.,  46.,  47.,  48.,  45.,  46.,  47.,  48.,  53.,  54.,  55.,  56.,
      57.,  58.,  59.,  60.,  61.,  62.,  63.,  64.,  61.,  62.,  63.,  64.,
      53.,  54.,  55.,  56.,  57.,  58.,  59.,  60.,  61.,  62.,  63.,  64.,
      61.,  62.,  63.,  64.,  85.,  86.,  87.,  88.,  89.,  90.,  91.,  92.,
      93.,  94.,  95.,  96.,  93.,  94.,  95.,  96.,  101., 102., 103., 104.,
      105., 106., 107., 108., 109., 110., 111., 112., 109., 110., 111., 112.,
      117., 118., 119., 120., 121., 122., 123., 124., 125., 126., 127., 128.,
      125., 126., 127., 128., 117., 118., 119., 120., 121., 122., 123., 124.,
      125., 126., 127., 128., 125., 126., 127., 128., 149., 150., 151., 152.,
      153., 154., 155., 156., 157., 158., 159., 160., 157., 158., 159., 160.,
      165., 166., 167., 168., 169., 170., 171., 172., 173., 174., 175., 176.,
      173., 174., 175., 176., 181., 182., 183., 184., 185., 186., 187., 188.,
      189., 190., 191., 192., 189., 190., 191., 192., 181., 182., 183., 184.,
      185., 186., 187., 188., 189., 190., 191., 192., 189., 190., 191., 192.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<3, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow3Stride1Forward, VALID3x4x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      41.,  42.,  43.,  44.,  45.,  46.,  47.,  48.,  57.,  58.,  59.,  60.,
      61.,  62.,  63.,  64.,  105., 106., 107., 108., 109., 110., 111., 112.,
      121., 122., 123., 124., 125., 126., 127., 128., 169., 170., 171., 172.,
      173., 174., 175., 176., 185., 186., 187., 188., 189., 190., 191., 192.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<3, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow3Stride1Forward, SAME3x4x5x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      7.,  8.,  9.,  10., 10., 12., 13., 14., 15., 15., 17., 18.,
      19., 20., 20., 17., 18., 19., 20., 20., 27., 28., 29., 30.,
      30., 32., 33., 34., 35., 35., 37., 38., 39., 40., 40., 37.,
      38., 39., 40., 40., 47., 48., 49., 50., 50., 52., 53., 54.,
      55., 55., 57., 58., 59., 60., 60., 57., 58., 59., 60., 60.};
  const std::array<int, 4> in_shape = {{3, 4, 5, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<3, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow3Stride1Forward, VALID3x4x5x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {13., 14., 15., 18., 19., 20.,
                                         33., 34., 35., 38., 39., 40.,
                                         53., 54., 55., 58., 59., 60.};
  const std::array<int, 4> in_shape = {{3, 4, 5, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<3, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow3Stride1Forward, SAME3x4x5x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      13.,  14.,  15.,  16.,  17.,  18.,  19.,  20.,  19.,  20.,  23.,  24.,
      25.,  26.,  27.,  28.,  29.,  30.,  29.,  30.,  33.,  34.,  35.,  36.,
      37.,  38.,  39.,  40.,  39.,  40.,  33.,  34.,  35.,  36.,  37.,  38.,
      39.,  40.,  39.,  40.,  53.,  54.,  55.,  56.,  57.,  58.,  59.,  60.,
      59.,  60.,  63.,  64.,  65.,  66.,  67.,  68.,  69.,  70.,  69.,  70.,
      73.,  74.,  75.,  76.,  77.,  78.,  79.,  80.,  79.,  80.,  73.,  74.,
      75.,  76.,  77.,  78.,  79.,  80.,  79.,  80.,  93.,  94.,  95.,  96.,
      97.,  98.,  99.,  100., 99.,  100., 103., 104., 105., 106., 107., 108.,
      109., 110., 109., 110., 113., 114., 115., 116., 117., 118., 119., 120.,
      119., 120., 113., 114., 115., 116., 117., 118., 119., 120., 119., 120.};
  const std::array<int, 4> in_shape = {{3, 4, 5, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<3, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow3Stride1Forward, VALID3x4x5x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      25.,  26.,  27.,  28.,  29.,  30.,  35.,  36.,  37.,  38.,  39.,  40.,
      65.,  66.,  67.,  68.,  69.,  70.,  75.,  76.,  77.,  78.,  79.,  80.,
      105., 106., 107., 108., 109., 110., 115., 116., 117., 118., 119., 120.};
  const std::array<int, 4> in_shape = {{3, 4, 5, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<3, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow3Stride1Forward, SAME3x4x5x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      25.,  26.,  27.,  28.,  29.,  30.,  31.,  32.,  33.,  34.,  35.,  36.,
      37.,  38.,  39.,  40.,  37.,  38.,  39.,  40.,  45.,  46.,  47.,  48.,
      49.,  50.,  51.,  52.,  53.,  54.,  55.,  56.,  57.,  58.,  59.,  60.,
      57.,  58.,  59.,  60.,  65.,  66.,  67.,  68.,  69.,  70.,  71.,  72.,
      73.,  74.,  75.,  76.,  77.,  78.,  79.,  80.,  77.,  78.,  79.,  80.,
      65.,  66.,  67.,  68.,  69.,  70.,  71.,  72.,  73.,  74.,  75.,  76.,
      77.,  78.,  79.,  80.,  77.,  78.,  79.,  80.,  105., 106., 107., 108.,
      109., 110., 111., 112., 113., 114., 115., 116., 117., 118., 119., 120.,
      117., 118., 119., 120., 125., 126., 127., 128., 129., 130., 131., 132.,
      133., 134., 135., 136., 137., 138., 139., 140., 137., 138., 139., 140.,
      145., 146., 147., 148., 149., 150., 151., 152., 153., 154., 155., 156.,
      157., 158., 159., 160., 157., 158., 159., 160., 145., 146., 147., 148.,
      149., 150., 151., 152., 153., 154., 155., 156., 157., 158., 159., 160.,
      157., 158., 159., 160., 185., 186., 187., 188., 189., 190., 191., 192.,
      193., 194., 195., 196., 197., 198., 199., 200., 197., 198., 199., 200.,
      205., 206., 207., 208., 209., 210., 211., 212., 213., 214., 215., 216.,
      217., 218., 219., 220., 217., 218., 219., 220., 225., 226., 227., 228.,
      229., 230., 231., 232., 233., 234., 235., 236., 237., 238., 239., 240.,
      237., 238., 239., 240., 225., 226., 227., 228., 229., 230., 231., 232.,
      233., 234., 235., 236., 237., 238., 239., 240., 237., 238., 239., 240.};
  const std::array<int, 4> in_shape = {{3, 4, 5, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<3, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow3Stride1Forward, VALID3x4x5x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      49.,  50.,  51.,  52.,  53.,  54.,  55.,  56.,  57.,  58.,  59.,  60.,
      69.,  70.,  71.,  72.,  73.,  74.,  75.,  76.,  77.,  78.,  79.,  80.,
      129., 130., 131., 132., 133., 134., 135., 136., 137., 138., 139., 140.,
      149., 150., 151., 152., 153., 154., 155., 156., 157., 158., 159., 160.,
      209., 210., 211., 212., 213., 214., 215., 216., 217., 218., 219., 220.,
      229., 230., 231., 232., 233., 234., 235., 236., 237., 238., 239., 240.};
  const std::array<int, 4> in_shape = {{3, 4, 5, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<3, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow3Stride1Forward, SAME3x4x6x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      8.,  9.,  10., 11., 12., 12., 14., 15., 16., 17., 18., 18., 20., 21., 22.,
      23., 24., 24., 20., 21., 22., 23., 24., 24., 32., 33., 34., 35., 36., 36.,
      38., 39., 40., 41., 42., 42., 44., 45., 46., 47., 48., 48., 44., 45., 46.,
      47., 48., 48., 56., 57., 58., 59., 60., 60., 62., 63., 64., 65., 66., 66.,
      68., 69., 70., 71., 72., 72., 68., 69., 70., 71., 72., 72.};
  const std::array<int, 4> in_shape = {{3, 4, 6, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<3, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow3Stride1Forward, VALID3x4x6x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      15., 16., 17., 18., 21., 22., 23., 24., 39., 40., 41., 42.,
      45., 46., 47., 48., 63., 64., 65., 66., 69., 70., 71., 72.};
  const std::array<int, 4> in_shape = {{3, 4, 6, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<3, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow3Stride1Forward, SAME3x4x6x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      15.,  16.,  17.,  18.,  19.,  20.,  21.,  22.,  23.,  24.,  23.,  24.,
      27.,  28.,  29.,  30.,  31.,  32.,  33.,  34.,  35.,  36.,  35.,  36.,
      39.,  40.,  41.,  42.,  43.,  44.,  45.,  46.,  47.,  48.,  47.,  48.,
      39.,  40.,  41.,  42.,  43.,  44.,  45.,  46.,  47.,  48.,  47.,  48.,
      63.,  64.,  65.,  66.,  67.,  68.,  69.,  70.,  71.,  72.,  71.,  72.,
      75.,  76.,  77.,  78.,  79.,  80.,  81.,  82.,  83.,  84.,  83.,  84.,
      87.,  88.,  89.,  90.,  91.,  92.,  93.,  94.,  95.,  96.,  95.,  96.,
      87.,  88.,  89.,  90.,  91.,  92.,  93.,  94.,  95.,  96.,  95.,  96.,
      111., 112., 113., 114., 115., 116., 117., 118., 119., 120., 119., 120.,
      123., 124., 125., 126., 127., 128., 129., 130., 131., 132., 131., 132.,
      135., 136., 137., 138., 139., 140., 141., 142., 143., 144., 143., 144.,
      135., 136., 137., 138., 139., 140., 141., 142., 143., 144., 143., 144.};
  const std::array<int, 4> in_shape = {{3, 4, 6, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<3, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow3Stride1Forward, VALID3x4x6x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      29.,  30.,  31.,  32.,  33.,  34.,  35.,  36.,  41.,  42.,  43.,  44.,
      45.,  46.,  47.,  48.,  77.,  78.,  79.,  80.,  81.,  82.,  83.,  84.,
      89.,  90.,  91.,  92.,  93.,  94.,  95.,  96.,  125., 126., 127., 128.,
      129., 130., 131., 132., 137., 138., 139., 140., 141., 142., 143., 144.};
  const std::array<int, 4> in_shape = {{3, 4, 6, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<3, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow3Stride1Forward, SAME3x4x6x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      29.,  30.,  31.,  32.,  33.,  34.,  35.,  36.,  37.,  38.,  39.,  40.,
      41.,  42.,  43.,  44.,  45.,  46.,  47.,  48.,  45.,  46.,  47.,  48.,
      53.,  54.,  55.,  56.,  57.,  58.,  59.,  60.,  61.,  62.,  63.,  64.,
      65.,  66.,  67.,  68.,  69.,  70.,  71.,  72.,  69.,  70.,  71.,  72.,
      77.,  78.,  79.,  80.,  81.,  82.,  83.,  84.,  85.,  86.,  87.,  88.,
      89.,  90.,  91.,  92.,  93.,  94.,  95.,  96.,  93.,  94.,  95.,  96.,
      77.,  78.,  79.,  80.,  81.,  82.,  83.,  84.,  85.,  86.,  87.,  88.,
      89.,  90.,  91.,  92.,  93.,  94.,  95.,  96.,  93.,  94.,  95.,  96.,
      125., 126., 127., 128., 129., 130., 131., 132., 133., 134., 135., 136.,
      137., 138., 139., 140., 141., 142., 143., 144., 141., 142., 143., 144.,
      149., 150., 151., 152., 153., 154., 155., 156., 157., 158., 159., 160.,
      161., 162., 163., 164., 165., 166., 167., 168., 165., 166., 167., 168.,
      173., 174., 175., 176., 177., 178., 179., 180., 181., 182., 183., 184.,
      185., 186., 187., 188., 189., 190., 191., 192., 189., 190., 191., 192.,
      173., 174., 175., 176., 177., 178., 179., 180., 181., 182., 183., 184.,
      185., 186., 187., 188., 189., 190., 191., 192., 189., 190., 191., 192.,
      221., 222., 223., 224., 225., 226., 227., 228., 229., 230., 231., 232.,
      233., 234., 235., 236., 237., 238., 239., 240., 237., 238., 239., 240.,
      245., 246., 247., 248., 249., 250., 251., 252., 253., 254., 255., 256.,
      257., 258., 259., 260., 261., 262., 263., 264., 261., 262., 263., 264.,
      269., 270., 271., 272., 273., 274., 275., 276., 277., 278., 279., 280.,
      281., 282., 283., 284., 285., 286., 287., 288., 285., 286., 287., 288.,
      269., 270., 271., 272., 273., 274., 275., 276., 277., 278., 279., 280.,
      281., 282., 283., 284., 285., 286., 287., 288., 285., 286., 287., 288.};
  const std::array<int, 4> in_shape = {{3, 4, 6, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<3, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow3Stride1Forward, VALID3x4x6x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      57.,  58.,  59.,  60.,  61.,  62.,  63.,  64.,  65.,  66.,  67.,  68.,
      69.,  70.,  71.,  72.,  81.,  82.,  83.,  84.,  85.,  86.,  87.,  88.,
      89.,  90.,  91.,  92.,  93.,  94.,  95.,  96.,  153., 154., 155., 156.,
      157., 158., 159., 160., 161., 162., 163., 164., 165., 166., 167., 168.,
      177., 178., 179., 180., 181., 182., 183., 184., 185., 186., 187., 188.,
      189., 190., 191., 192., 249., 250., 251., 252., 253., 254., 255., 256.,
      257., 258., 259., 260., 261., 262., 263., 264., 273., 274., 275., 276.,
      277., 278., 279., 280., 281., 282., 283., 284., 285., 286., 287., 288.};
  const std::array<int, 4> in_shape = {{3, 4, 6, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<3, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow3Stride1Forward, SAME3x5x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      6.,  7.,  8.,  8.,  10., 11., 12., 12., 14., 15., 16., 16.,
      18., 19., 20., 20., 18., 19., 20., 20., 26., 27., 28., 28.,
      30., 31., 32., 32., 34., 35., 36., 36., 38., 39., 40., 40.,
      38., 39., 40., 40., 46., 47., 48., 48., 50., 51., 52., 52.,
      54., 55., 56., 56., 58., 59., 60., 60., 58., 59., 60., 60.};
  const std::array<int, 4> in_shape = {{3, 5, 4, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<3, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow3Stride1Forward, VALID3x5x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {11., 12., 15., 16., 19., 20.,
                                         31., 32., 35., 36., 39., 40.,
                                         51., 52., 55., 56., 59., 60.};
  const std::array<int, 4> in_shape = {{3, 5, 4, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<3, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow3Stride1Forward, SAME3x5x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      11.,  12.,  13.,  14.,  15.,  16.,  15.,  16.,  19.,  20.,  21.,  22.,
      23.,  24.,  23.,  24.,  27.,  28.,  29.,  30.,  31.,  32.,  31.,  32.,
      35.,  36.,  37.,  38.,  39.,  40.,  39.,  40.,  35.,  36.,  37.,  38.,
      39.,  40.,  39.,  40.,  51.,  52.,  53.,  54.,  55.,  56.,  55.,  56.,
      59.,  60.,  61.,  62.,  63.,  64.,  63.,  64.,  67.,  68.,  69.,  70.,
      71.,  72.,  71.,  72.,  75.,  76.,  77.,  78.,  79.,  80.,  79.,  80.,
      75.,  76.,  77.,  78.,  79.,  80.,  79.,  80.,  91.,  92.,  93.,  94.,
      95.,  96.,  95.,  96.,  99.,  100., 101., 102., 103., 104., 103., 104.,
      107., 108., 109., 110., 111., 112., 111., 112., 115., 116., 117., 118.,
      119., 120., 119., 120., 115., 116., 117., 118., 119., 120., 119., 120.};
  const std::array<int, 4> in_shape = {{3, 5, 4, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<3, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow3Stride1Forward, VALID3x5x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      21.,  22.,  23.,  24.,  29.,  30.,  31.,  32.,  37.,  38.,  39.,  40.,
      61.,  62.,  63.,  64.,  69.,  70.,  71.,  72.,  77.,  78.,  79.,  80.,
      101., 102., 103., 104., 109., 110., 111., 112., 117., 118., 119., 120.};
  const std::array<int, 4> in_shape = {{3, 5, 4, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<3, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow3Stride1Forward, SAME3x5x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      21.,  22.,  23.,  24.,  25.,  26.,  27.,  28.,  29.,  30.,  31.,  32.,
      29.,  30.,  31.,  32.,  37.,  38.,  39.,  40.,  41.,  42.,  43.,  44.,
      45.,  46.,  47.,  48.,  45.,  46.,  47.,  48.,  53.,  54.,  55.,  56.,
      57.,  58.,  59.,  60.,  61.,  62.,  63.,  64.,  61.,  62.,  63.,  64.,
      69.,  70.,  71.,  72.,  73.,  74.,  75.,  76.,  77.,  78.,  79.,  80.,
      77.,  78.,  79.,  80.,  69.,  70.,  71.,  72.,  73.,  74.,  75.,  76.,
      77.,  78.,  79.,  80.,  77.,  78.,  79.,  80.,  101., 102., 103., 104.,
      105., 106., 107., 108., 109., 110., 111., 112., 109., 110., 111., 112.,
      117., 118., 119., 120., 121., 122., 123., 124., 125., 126., 127., 128.,
      125., 126., 127., 128., 133., 134., 135., 136., 137., 138., 139., 140.,
      141., 142., 143., 144., 141., 142., 143., 144., 149., 150., 151., 152.,
      153., 154., 155., 156., 157., 158., 159., 160., 157., 158., 159., 160.,
      149., 150., 151., 152., 153., 154., 155., 156., 157., 158., 159., 160.,
      157., 158., 159., 160., 181., 182., 183., 184., 185., 186., 187., 188.,
      189., 190., 191., 192., 189., 190., 191., 192., 197., 198., 199., 200.,
      201., 202., 203., 204., 205., 206., 207., 208., 205., 206., 207., 208.,
      213., 214., 215., 216., 217., 218., 219., 220., 221., 222., 223., 224.,
      221., 222., 223., 224., 229., 230., 231., 232., 233., 234., 235., 236.,
      237., 238., 239., 240., 237., 238., 239., 240., 229., 230., 231., 232.,
      233., 234., 235., 236., 237., 238., 239., 240., 237., 238., 239., 240.};
  const std::array<int, 4> in_shape = {{3, 5, 4, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<3, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow3Stride1Forward, VALID3x5x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      41.,  42.,  43.,  44.,  45.,  46.,  47.,  48.,  57.,  58.,  59.,  60.,
      61.,  62.,  63.,  64.,  73.,  74.,  75.,  76.,  77.,  78.,  79.,  80.,
      121., 122., 123., 124., 125., 126., 127., 128., 137., 138., 139., 140.,
      141., 142., 143., 144., 153., 154., 155., 156., 157., 158., 159., 160.,
      201., 202., 203., 204., 205., 206., 207., 208., 217., 218., 219., 220.,
      221., 222., 223., 224., 233., 234., 235., 236., 237., 238., 239., 240.};
  const std::array<int, 4> in_shape = {{3, 5, 4, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<3, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow3Stride1Forward, SAME3x5x5x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      7.,  8.,  9.,  10., 10., 12., 13., 14., 15., 15., 17., 18., 19.,
      20., 20., 22., 23., 24., 25., 25., 22., 23., 24., 25., 25., 32.,
      33., 34., 35., 35., 37., 38., 39., 40., 40., 42., 43., 44., 45.,
      45., 47., 48., 49., 50., 50., 47., 48., 49., 50., 50., 57., 58.,
      59., 60., 60., 62., 63., 64., 65., 65., 67., 68., 69., 70., 70.,
      72., 73., 74., 75., 75., 72., 73., 74., 75., 75.};
  const std::array<int, 4> in_shape = {{3, 5, 5, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<3, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow3Stride1Forward, VALID3x5x5x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      13., 14., 15., 18., 19., 20., 23., 24., 25., 38., 39., 40., 43., 44.,
      45., 48., 49., 50., 63., 64., 65., 68., 69., 70., 73., 74., 75.};
  const std::array<int, 4> in_shape = {{3, 5, 5, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<3, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow3Stride1Forward, SAME3x5x5x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      13.,  14.,  15.,  16.,  17.,  18.,  19.,  20.,  19.,  20.,  23.,  24.,
      25.,  26.,  27.,  28.,  29.,  30.,  29.,  30.,  33.,  34.,  35.,  36.,
      37.,  38.,  39.,  40.,  39.,  40.,  43.,  44.,  45.,  46.,  47.,  48.,
      49.,  50.,  49.,  50.,  43.,  44.,  45.,  46.,  47.,  48.,  49.,  50.,
      49.,  50.,  63.,  64.,  65.,  66.,  67.,  68.,  69.,  70.,  69.,  70.,
      73.,  74.,  75.,  76.,  77.,  78.,  79.,  80.,  79.,  80.,  83.,  84.,
      85.,  86.,  87.,  88.,  89.,  90.,  89.,  90.,  93.,  94.,  95.,  96.,
      97.,  98.,  99.,  100., 99.,  100., 93.,  94.,  95.,  96.,  97.,  98.,
      99.,  100., 99.,  100., 113., 114., 115., 116., 117., 118., 119., 120.,
      119., 120., 123., 124., 125., 126., 127., 128., 129., 130., 129., 130.,
      133., 134., 135., 136., 137., 138., 139., 140., 139., 140., 143., 144.,
      145., 146., 147., 148., 149., 150., 149., 150., 143., 144., 145., 146.,
      147., 148., 149., 150., 149., 150.};
  const std::array<int, 4> in_shape = {{3, 5, 5, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<3, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow3Stride1Forward, VALID3x5x5x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      25.,  26.,  27.,  28.,  29.,  30.,  35.,  36.,  37.,  38.,  39.,
      40.,  45.,  46.,  47.,  48.,  49.,  50.,  75.,  76.,  77.,  78.,
      79.,  80.,  85.,  86.,  87.,  88.,  89.,  90.,  95.,  96.,  97.,
      98.,  99.,  100., 125., 126., 127., 128., 129., 130., 135., 136.,
      137., 138., 139., 140., 145., 146., 147., 148., 149., 150.};
  const std::array<int, 4> in_shape = {{3, 5, 5, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<3, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow3Stride1Forward, SAME3x5x5x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      25.,  26.,  27.,  28.,  29.,  30.,  31.,  32.,  33.,  34.,  35.,  36.,
      37.,  38.,  39.,  40.,  37.,  38.,  39.,  40.,  45.,  46.,  47.,  48.,
      49.,  50.,  51.,  52.,  53.,  54.,  55.,  56.,  57.,  58.,  59.,  60.,
      57.,  58.,  59.,  60.,  65.,  66.,  67.,  68.,  69.,  70.,  71.,  72.,
      73.,  74.,  75.,  76.,  77.,  78.,  79.,  80.,  77.,  78.,  79.,  80.,
      85.,  86.,  87.,  88.,  89.,  90.,  91.,  92.,  93.,  94.,  95.,  96.,
      97.,  98.,  99.,  100., 97.,  98.,  99.,  100., 85.,  86.,  87.,  88.,
      89.,  90.,  91.,  92.,  93.,  94.,  95.,  96.,  97.,  98.,  99.,  100.,
      97.,  98.,  99.,  100., 125., 126., 127., 128., 129., 130., 131., 132.,
      133., 134., 135., 136., 137., 138., 139., 140., 137., 138., 139., 140.,
      145., 146., 147., 148., 149., 150., 151., 152., 153., 154., 155., 156.,
      157., 158., 159., 160., 157., 158., 159., 160., 165., 166., 167., 168.,
      169., 170., 171., 172., 173., 174., 175., 176., 177., 178., 179., 180.,
      177., 178., 179., 180., 185., 186., 187., 188., 189., 190., 191., 192.,
      193., 194., 195., 196., 197., 198., 199., 200., 197., 198., 199., 200.,
      185., 186., 187., 188., 189., 190., 191., 192., 193., 194., 195., 196.,
      197., 198., 199., 200., 197., 198., 199., 200., 225., 226., 227., 228.,
      229., 230., 231., 232., 233., 234., 235., 236., 237., 238., 239., 240.,
      237., 238., 239., 240., 245., 246., 247., 248., 249., 250., 251., 252.,
      253., 254., 255., 256., 257., 258., 259., 260., 257., 258., 259., 260.,
      265., 266., 267., 268., 269., 270., 271., 272., 273., 274., 275., 276.,
      277., 278., 279., 280., 277., 278., 279., 280., 285., 286., 287., 288.,
      289., 290., 291., 292., 293., 294., 295., 296., 297., 298., 299., 300.,
      297., 298., 299., 300., 285., 286., 287., 288., 289., 290., 291., 292.,
      293., 294., 295., 296., 297., 298., 299., 300., 297., 298., 299., 300.};
  const std::array<int, 4> in_shape = {{3, 5, 5, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<3, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow3Stride1Forward, VALID3x5x5x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      49.,  50.,  51.,  52.,  53.,  54.,  55.,  56.,  57.,  58.,  59.,  60.,
      69.,  70.,  71.,  72.,  73.,  74.,  75.,  76.,  77.,  78.,  79.,  80.,
      89.,  90.,  91.,  92.,  93.,  94.,  95.,  96.,  97.,  98.,  99.,  100.,
      149., 150., 151., 152., 153., 154., 155., 156., 157., 158., 159., 160.,
      169., 170., 171., 172., 173., 174., 175., 176., 177., 178., 179., 180.,
      189., 190., 191., 192., 193., 194., 195., 196., 197., 198., 199., 200.,
      249., 250., 251., 252., 253., 254., 255., 256., 257., 258., 259., 260.,
      269., 270., 271., 272., 273., 274., 275., 276., 277., 278., 279., 280.,
      289., 290., 291., 292., 293., 294., 295., 296., 297., 298., 299., 300.};
  const std::array<int, 4> in_shape = {{3, 5, 5, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<3, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow3Stride1Forward, SAME3x5x6x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      8.,  9.,  10., 11., 12., 12., 14., 15., 16., 17., 18., 18., 20.,
      21., 22., 23., 24., 24., 26., 27., 28., 29., 30., 30., 26., 27.,
      28., 29., 30., 30., 38., 39., 40., 41., 42., 42., 44., 45., 46.,
      47., 48., 48., 50., 51., 52., 53., 54., 54., 56., 57., 58., 59.,
      60., 60., 56., 57., 58., 59., 60., 60., 68., 69., 70., 71., 72.,
      72., 74., 75., 76., 77., 78., 78., 80., 81., 82., 83., 84., 84.,
      86., 87., 88., 89., 90., 90., 86., 87., 88., 89., 90., 90.};
  const std::array<int, 4> in_shape = {{3, 5, 6, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<3, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow3Stride1Forward, VALID3x5x6x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      15., 16., 17., 18., 21., 22., 23., 24., 27., 28., 29., 30.,
      45., 46., 47., 48., 51., 52., 53., 54., 57., 58., 59., 60.,
      75., 76., 77., 78., 81., 82., 83., 84., 87., 88., 89., 90.};
  const std::array<int, 4> in_shape = {{3, 5, 6, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<3, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow3Stride1Forward, SAME3x5x6x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      15.,  16.,  17.,  18.,  19.,  20.,  21.,  22.,  23.,  24.,  23.,  24.,
      27.,  28.,  29.,  30.,  31.,  32.,  33.,  34.,  35.,  36.,  35.,  36.,
      39.,  40.,  41.,  42.,  43.,  44.,  45.,  46.,  47.,  48.,  47.,  48.,
      51.,  52.,  53.,  54.,  55.,  56.,  57.,  58.,  59.,  60.,  59.,  60.,
      51.,  52.,  53.,  54.,  55.,  56.,  57.,  58.,  59.,  60.,  59.,  60.,
      75.,  76.,  77.,  78.,  79.,  80.,  81.,  82.,  83.,  84.,  83.,  84.,
      87.,  88.,  89.,  90.,  91.,  92.,  93.,  94.,  95.,  96.,  95.,  96.,
      99.,  100., 101., 102., 103., 104., 105., 106., 107., 108., 107., 108.,
      111., 112., 113., 114., 115., 116., 117., 118., 119., 120., 119., 120.,
      111., 112., 113., 114., 115., 116., 117., 118., 119., 120., 119., 120.,
      135., 136., 137., 138., 139., 140., 141., 142., 143., 144., 143., 144.,
      147., 148., 149., 150., 151., 152., 153., 154., 155., 156., 155., 156.,
      159., 160., 161., 162., 163., 164., 165., 166., 167., 168., 167., 168.,
      171., 172., 173., 174., 175., 176., 177., 178., 179., 180., 179., 180.,
      171., 172., 173., 174., 175., 176., 177., 178., 179., 180., 179., 180.};
  const std::array<int, 4> in_shape = {{3, 5, 6, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<3, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow3Stride1Forward, VALID3x5x6x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      29.,  30.,  31.,  32.,  33.,  34.,  35.,  36.,  41.,  42.,  43.,  44.,
      45.,  46.,  47.,  48.,  53.,  54.,  55.,  56.,  57.,  58.,  59.,  60.,
      89.,  90.,  91.,  92.,  93.,  94.,  95.,  96.,  101., 102., 103., 104.,
      105., 106., 107., 108., 113., 114., 115., 116., 117., 118., 119., 120.,
      149., 150., 151., 152., 153., 154., 155., 156., 161., 162., 163., 164.,
      165., 166., 167., 168., 173., 174., 175., 176., 177., 178., 179., 180.};
  const std::array<int, 4> in_shape = {{3, 5, 6, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<3, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow3Stride1Forward, SAME3x5x6x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      29.,  30.,  31.,  32.,  33.,  34.,  35.,  36.,  37.,  38.,  39.,  40.,
      41.,  42.,  43.,  44.,  45.,  46.,  47.,  48.,  45.,  46.,  47.,  48.,
      53.,  54.,  55.,  56.,  57.,  58.,  59.,  60.,  61.,  62.,  63.,  64.,
      65.,  66.,  67.,  68.,  69.,  70.,  71.,  72.,  69.,  70.,  71.,  72.,
      77.,  78.,  79.,  80.,  81.,  82.,  83.,  84.,  85.,  86.,  87.,  88.,
      89.,  90.,  91.,  92.,  93.,  94.,  95.,  96.,  93.,  94.,  95.,  96.,
      101., 102., 103., 104., 105., 106., 107., 108., 109., 110., 111., 112.,
      113., 114., 115., 116., 117., 118., 119., 120., 117., 118., 119., 120.,
      101., 102., 103., 104., 105., 106., 107., 108., 109., 110., 111., 112.,
      113., 114., 115., 116., 117., 118., 119., 120., 117., 118., 119., 120.,
      149., 150., 151., 152., 153., 154., 155., 156., 157., 158., 159., 160.,
      161., 162., 163., 164., 165., 166., 167., 168., 165., 166., 167., 168.,
      173., 174., 175., 176., 177., 178., 179., 180., 181., 182., 183., 184.,
      185., 186., 187., 188., 189., 190., 191., 192., 189., 190., 191., 192.,
      197., 198., 199., 200., 201., 202., 203., 204., 205., 206., 207., 208.,
      209., 210., 211., 212., 213., 214., 215., 216., 213., 214., 215., 216.,
      221., 222., 223., 224., 225., 226., 227., 228., 229., 230., 231., 232.,
      233., 234., 235., 236., 237., 238., 239., 240., 237., 238., 239., 240.,
      221., 222., 223., 224., 225., 226., 227., 228., 229., 230., 231., 232.,
      233., 234., 235., 236., 237., 238., 239., 240., 237., 238., 239., 240.,
      269., 270., 271., 272., 273., 274., 275., 276., 277., 278., 279., 280.,
      281., 282., 283., 284., 285., 286., 287., 288., 285., 286., 287., 288.,
      293., 294., 295., 296., 297., 298., 299., 300., 301., 302., 303., 304.,
      305., 306., 307., 308., 309., 310., 311., 312., 309., 310., 311., 312.,
      317., 318., 319., 320., 321., 322., 323., 324., 325., 326., 327., 328.,
      329., 330., 331., 332., 333., 334., 335., 336., 333., 334., 335., 336.,
      341., 342., 343., 344., 345., 346., 347., 348., 349., 350., 351., 352.,
      353., 354., 355., 356., 357., 358., 359., 360., 357., 358., 359., 360.,
      341., 342., 343., 344., 345., 346., 347., 348., 349., 350., 351., 352.,
      353., 354., 355., 356., 357., 358., 359., 360., 357., 358., 359., 360.};
  const std::array<int, 4> in_shape = {{3, 5, 6, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<3, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow3Stride1Forward, VALID3x5x6x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      57.,  58.,  59.,  60.,  61.,  62.,  63.,  64.,  65.,  66.,  67.,  68.,
      69.,  70.,  71.,  72.,  81.,  82.,  83.,  84.,  85.,  86.,  87.,  88.,
      89.,  90.,  91.,  92.,  93.,  94.,  95.,  96.,  105., 106., 107., 108.,
      109., 110., 111., 112., 113., 114., 115., 116., 117., 118., 119., 120.,
      177., 178., 179., 180., 181., 182., 183., 184., 185., 186., 187., 188.,
      189., 190., 191., 192., 201., 202., 203., 204., 205., 206., 207., 208.,
      209., 210., 211., 212., 213., 214., 215., 216., 225., 226., 227., 228.,
      229., 230., 231., 232., 233., 234., 235., 236., 237., 238., 239., 240.,
      297., 298., 299., 300., 301., 302., 303., 304., 305., 306., 307., 308.,
      309., 310., 311., 312., 321., 322., 323., 324., 325., 326., 327., 328.,
      329., 330., 331., 332., 333., 334., 335., 336., 345., 346., 347., 348.,
      349., 350., 351., 352., 353., 354., 355., 356., 357., 358., 359., 360.};
  const std::array<int, 4> in_shape = {{3, 5, 6, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<3, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow3Stride1Forward, SAME3x6x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      6.,  7.,  8.,  8.,  10., 11., 12., 12., 14., 15., 16., 16., 18., 19., 20.,
      20., 22., 23., 24., 24., 22., 23., 24., 24., 30., 31., 32., 32., 34., 35.,
      36., 36., 38., 39., 40., 40., 42., 43., 44., 44., 46., 47., 48., 48., 46.,
      47., 48., 48., 54., 55., 56., 56., 58., 59., 60., 60., 62., 63., 64., 64.,
      66., 67., 68., 68., 70., 71., 72., 72., 70., 71., 72., 72.};
  const std::array<int, 4> in_shape = {{3, 6, 4, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<3, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow3Stride1Forward, VALID3x6x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      11., 12., 15., 16., 19., 20., 23., 24., 35., 36., 39., 40.,
      43., 44., 47., 48., 59., 60., 63., 64., 67., 68., 71., 72.};
  const std::array<int, 4> in_shape = {{3, 6, 4, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<3, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow3Stride1Forward, SAME3x6x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      11.,  12.,  13.,  14.,  15.,  16.,  15.,  16.,  19.,  20.,  21.,  22.,
      23.,  24.,  23.,  24.,  27.,  28.,  29.,  30.,  31.,  32.,  31.,  32.,
      35.,  36.,  37.,  38.,  39.,  40.,  39.,  40.,  43.,  44.,  45.,  46.,
      47.,  48.,  47.,  48.,  43.,  44.,  45.,  46.,  47.,  48.,  47.,  48.,
      59.,  60.,  61.,  62.,  63.,  64.,  63.,  64.,  67.,  68.,  69.,  70.,
      71.,  72.,  71.,  72.,  75.,  76.,  77.,  78.,  79.,  80.,  79.,  80.,
      83.,  84.,  85.,  86.,  87.,  88.,  87.,  88.,  91.,  92.,  93.,  94.,
      95.,  96.,  95.,  96.,  91.,  92.,  93.,  94.,  95.,  96.,  95.,  96.,
      107., 108., 109., 110., 111., 112., 111., 112., 115., 116., 117., 118.,
      119., 120., 119., 120., 123., 124., 125., 126., 127., 128., 127., 128.,
      131., 132., 133., 134., 135., 136., 135., 136., 139., 140., 141., 142.,
      143., 144., 143., 144., 139., 140., 141., 142., 143., 144., 143., 144.};
  const std::array<int, 4> in_shape = {{3, 6, 4, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<3, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow3Stride1Forward, VALID3x6x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      21.,  22.,  23.,  24.,  29.,  30.,  31.,  32.,  37.,  38.,  39.,  40.,
      45.,  46.,  47.,  48.,  69.,  70.,  71.,  72.,  77.,  78.,  79.,  80.,
      85.,  86.,  87.,  88.,  93.,  94.,  95.,  96.,  117., 118., 119., 120.,
      125., 126., 127., 128., 133., 134., 135., 136., 141., 142., 143., 144.};
  const std::array<int, 4> in_shape = {{3, 6, 4, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<3, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow3Stride1Forward, SAME3x6x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      21.,  22.,  23.,  24.,  25.,  26.,  27.,  28.,  29.,  30.,  31.,  32.,
      29.,  30.,  31.,  32.,  37.,  38.,  39.,  40.,  41.,  42.,  43.,  44.,
      45.,  46.,  47.,  48.,  45.,  46.,  47.,  48.,  53.,  54.,  55.,  56.,
      57.,  58.,  59.,  60.,  61.,  62.,  63.,  64.,  61.,  62.,  63.,  64.,
      69.,  70.,  71.,  72.,  73.,  74.,  75.,  76.,  77.,  78.,  79.,  80.,
      77.,  78.,  79.,  80.,  85.,  86.,  87.,  88.,  89.,  90.,  91.,  92.,
      93.,  94.,  95.,  96.,  93.,  94.,  95.,  96.,  85.,  86.,  87.,  88.,
      89.,  90.,  91.,  92.,  93.,  94.,  95.,  96.,  93.,  94.,  95.,  96.,
      117., 118., 119., 120., 121., 122., 123., 124., 125., 126., 127., 128.,
      125., 126., 127., 128., 133., 134., 135., 136., 137., 138., 139., 140.,
      141., 142., 143., 144., 141., 142., 143., 144., 149., 150., 151., 152.,
      153., 154., 155., 156., 157., 158., 159., 160., 157., 158., 159., 160.,
      165., 166., 167., 168., 169., 170., 171., 172., 173., 174., 175., 176.,
      173., 174., 175., 176., 181., 182., 183., 184., 185., 186., 187., 188.,
      189., 190., 191., 192., 189., 190., 191., 192., 181., 182., 183., 184.,
      185., 186., 187., 188., 189., 190., 191., 192., 189., 190., 191., 192.,
      213., 214., 215., 216., 217., 218., 219., 220., 221., 222., 223., 224.,
      221., 222., 223., 224., 229., 230., 231., 232., 233., 234., 235., 236.,
      237., 238., 239., 240., 237., 238., 239., 240., 245., 246., 247., 248.,
      249., 250., 251., 252., 253., 254., 255., 256., 253., 254., 255., 256.,
      261., 262., 263., 264., 265., 266., 267., 268., 269., 270., 271., 272.,
      269., 270., 271., 272., 277., 278., 279., 280., 281., 282., 283., 284.,
      285., 286., 287., 288., 285., 286., 287., 288., 277., 278., 279., 280.,
      281., 282., 283., 284., 285., 286., 287., 288., 285., 286., 287., 288.};
  const std::array<int, 4> in_shape = {{3, 6, 4, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<3, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow3Stride1Forward, VALID3x6x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      41.,  42.,  43.,  44.,  45.,  46.,  47.,  48.,  57.,  58.,  59.,  60.,
      61.,  62.,  63.,  64.,  73.,  74.,  75.,  76.,  77.,  78.,  79.,  80.,
      89.,  90.,  91.,  92.,  93.,  94.,  95.,  96.,  137., 138., 139., 140.,
      141., 142., 143., 144., 153., 154., 155., 156., 157., 158., 159., 160.,
      169., 170., 171., 172., 173., 174., 175., 176., 185., 186., 187., 188.,
      189., 190., 191., 192., 233., 234., 235., 236., 237., 238., 239., 240.,
      249., 250., 251., 252., 253., 254., 255., 256., 265., 266., 267., 268.,
      269., 270., 271., 272., 281., 282., 283., 284., 285., 286., 287., 288.};
  const std::array<int, 4> in_shape = {{3, 6, 4, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<3, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow3Stride1Forward, SAME3x6x5x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      7.,  8.,  9.,  10., 10., 12., 13., 14., 15., 15., 17., 18., 19.,
      20., 20., 22., 23., 24., 25., 25., 27., 28., 29., 30., 30., 27.,
      28., 29., 30., 30., 37., 38., 39., 40., 40., 42., 43., 44., 45.,
      45., 47., 48., 49., 50., 50., 52., 53., 54., 55., 55., 57., 58.,
      59., 60., 60., 57., 58., 59., 60., 60., 67., 68., 69., 70., 70.,
      72., 73., 74., 75., 75., 77., 78., 79., 80., 80., 82., 83., 84.,
      85., 85., 87., 88., 89., 90., 90., 87., 88., 89., 90., 90.};
  const std::array<int, 4> in_shape = {{3, 6, 5, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<3, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow3Stride1Forward, VALID3x6x5x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      13., 14., 15., 18., 19., 20., 23., 24., 25., 28., 29., 30.,
      43., 44., 45., 48., 49., 50., 53., 54., 55., 58., 59., 60.,
      73., 74., 75., 78., 79., 80., 83., 84., 85., 88., 89., 90.};
  const std::array<int, 4> in_shape = {{3, 6, 5, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<3, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow3Stride1Forward, SAME3x6x5x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      13.,  14.,  15.,  16.,  17.,  18.,  19.,  20.,  19.,  20.,  23.,  24.,
      25.,  26.,  27.,  28.,  29.,  30.,  29.,  30.,  33.,  34.,  35.,  36.,
      37.,  38.,  39.,  40.,  39.,  40.,  43.,  44.,  45.,  46.,  47.,  48.,
      49.,  50.,  49.,  50.,  53.,  54.,  55.,  56.,  57.,  58.,  59.,  60.,
      59.,  60.,  53.,  54.,  55.,  56.,  57.,  58.,  59.,  60.,  59.,  60.,
      73.,  74.,  75.,  76.,  77.,  78.,  79.,  80.,  79.,  80.,  83.,  84.,
      85.,  86.,  87.,  88.,  89.,  90.,  89.,  90.,  93.,  94.,  95.,  96.,
      97.,  98.,  99.,  100., 99.,  100., 103., 104., 105., 106., 107., 108.,
      109., 110., 109., 110., 113., 114., 115., 116., 117., 118., 119., 120.,
      119., 120., 113., 114., 115., 116., 117., 118., 119., 120., 119., 120.,
      133., 134., 135., 136., 137., 138., 139., 140., 139., 140., 143., 144.,
      145., 146., 147., 148., 149., 150., 149., 150., 153., 154., 155., 156.,
      157., 158., 159., 160., 159., 160., 163., 164., 165., 166., 167., 168.,
      169., 170., 169., 170., 173., 174., 175., 176., 177., 178., 179., 180.,
      179., 180., 173., 174., 175., 176., 177., 178., 179., 180., 179., 180.};
  const std::array<int, 4> in_shape = {{3, 6, 5, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<3, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow3Stride1Forward, VALID3x6x5x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      25.,  26.,  27.,  28.,  29.,  30.,  35.,  36.,  37.,  38.,  39.,  40.,
      45.,  46.,  47.,  48.,  49.,  50.,  55.,  56.,  57.,  58.,  59.,  60.,
      85.,  86.,  87.,  88.,  89.,  90.,  95.,  96.,  97.,  98.,  99.,  100.,
      105., 106., 107., 108., 109., 110., 115., 116., 117., 118., 119., 120.,
      145., 146., 147., 148., 149., 150., 155., 156., 157., 158., 159., 160.,
      165., 166., 167., 168., 169., 170., 175., 176., 177., 178., 179., 180.};
  const std::array<int, 4> in_shape = {{3, 6, 5, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<3, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow3Stride1Forward, SAME3x6x5x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      25.,  26.,  27.,  28.,  29.,  30.,  31.,  32.,  33.,  34.,  35.,  36.,
      37.,  38.,  39.,  40.,  37.,  38.,  39.,  40.,  45.,  46.,  47.,  48.,
      49.,  50.,  51.,  52.,  53.,  54.,  55.,  56.,  57.,  58.,  59.,  60.,
      57.,  58.,  59.,  60.,  65.,  66.,  67.,  68.,  69.,  70.,  71.,  72.,
      73.,  74.,  75.,  76.,  77.,  78.,  79.,  80.,  77.,  78.,  79.,  80.,
      85.,  86.,  87.,  88.,  89.,  90.,  91.,  92.,  93.,  94.,  95.,  96.,
      97.,  98.,  99.,  100., 97.,  98.,  99.,  100., 105., 106., 107., 108.,
      109., 110., 111., 112., 113., 114., 115., 116., 117., 118., 119., 120.,
      117., 118., 119., 120., 105., 106., 107., 108., 109., 110., 111., 112.,
      113., 114., 115., 116., 117., 118., 119., 120., 117., 118., 119., 120.,
      145., 146., 147., 148., 149., 150., 151., 152., 153., 154., 155., 156.,
      157., 158., 159., 160., 157., 158., 159., 160., 165., 166., 167., 168.,
      169., 170., 171., 172., 173., 174., 175., 176., 177., 178., 179., 180.,
      177., 178., 179., 180., 185., 186., 187., 188., 189., 190., 191., 192.,
      193., 194., 195., 196., 197., 198., 199., 200., 197., 198., 199., 200.,
      205., 206., 207., 208., 209., 210., 211., 212., 213., 214., 215., 216.,
      217., 218., 219., 220., 217., 218., 219., 220., 225., 226., 227., 228.,
      229., 230., 231., 232., 233., 234., 235., 236., 237., 238., 239., 240.,
      237., 238., 239., 240., 225., 226., 227., 228., 229., 230., 231., 232.,
      233., 234., 235., 236., 237., 238., 239., 240., 237., 238., 239., 240.,
      265., 266., 267., 268., 269., 270., 271., 272., 273., 274., 275., 276.,
      277., 278., 279., 280., 277., 278., 279., 280., 285., 286., 287., 288.,
      289., 290., 291., 292., 293., 294., 295., 296., 297., 298., 299., 300.,
      297., 298., 299., 300., 305., 306., 307., 308., 309., 310., 311., 312.,
      313., 314., 315., 316., 317., 318., 319., 320., 317., 318., 319., 320.,
      325., 326., 327., 328., 329., 330., 331., 332., 333., 334., 335., 336.,
      337., 338., 339., 340., 337., 338., 339., 340., 345., 346., 347., 348.,
      349., 350., 351., 352., 353., 354., 355., 356., 357., 358., 359., 360.,
      357., 358., 359., 360., 345., 346., 347., 348., 349., 350., 351., 352.,
      353., 354., 355., 356., 357., 358., 359., 360., 357., 358., 359., 360.};
  const std::array<int, 4> in_shape = {{3, 6, 5, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<3, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow3Stride1Forward, VALID3x6x5x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      49.,  50.,  51.,  52.,  53.,  54.,  55.,  56.,  57.,  58.,  59.,  60.,
      69.,  70.,  71.,  72.,  73.,  74.,  75.,  76.,  77.,  78.,  79.,  80.,
      89.,  90.,  91.,  92.,  93.,  94.,  95.,  96.,  97.,  98.,  99.,  100.,
      109., 110., 111., 112., 113., 114., 115., 116., 117., 118., 119., 120.,
      169., 170., 171., 172., 173., 174., 175., 176., 177., 178., 179., 180.,
      189., 190., 191., 192., 193., 194., 195., 196., 197., 198., 199., 200.,
      209., 210., 211., 212., 213., 214., 215., 216., 217., 218., 219., 220.,
      229., 230., 231., 232., 233., 234., 235., 236., 237., 238., 239., 240.,
      289., 290., 291., 292., 293., 294., 295., 296., 297., 298., 299., 300.,
      309., 310., 311., 312., 313., 314., 315., 316., 317., 318., 319., 320.,
      329., 330., 331., 332., 333., 334., 335., 336., 337., 338., 339., 340.,
      349., 350., 351., 352., 353., 354., 355., 356., 357., 358., 359., 360.};
  const std::array<int, 4> in_shape = {{3, 6, 5, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<3, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow3Stride1Forward, SAME3x6x6x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      8.,   9.,   10.,  11.,  12.,  12.,  14.,  15.,  16.,  17.,  18.,  18.,
      20.,  21.,  22.,  23.,  24.,  24.,  26.,  27.,  28.,  29.,  30.,  30.,
      32.,  33.,  34.,  35.,  36.,  36.,  32.,  33.,  34.,  35.,  36.,  36.,
      44.,  45.,  46.,  47.,  48.,  48.,  50.,  51.,  52.,  53.,  54.,  54.,
      56.,  57.,  58.,  59.,  60.,  60.,  62.,  63.,  64.,  65.,  66.,  66.,
      68.,  69.,  70.,  71.,  72.,  72.,  68.,  69.,  70.,  71.,  72.,  72.,
      80.,  81.,  82.,  83.,  84.,  84.,  86.,  87.,  88.,  89.,  90.,  90.,
      92.,  93.,  94.,  95.,  96.,  96.,  98.,  99.,  100., 101., 102., 102.,
      104., 105., 106., 107., 108., 108., 104., 105., 106., 107., 108., 108.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 1}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<3, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow3Stride1Forward, VALID3x6x6x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      15., 16., 17., 18., 21., 22.,  23.,  24.,  27.,  28.,  29.,  30.,
      33., 34., 35., 36., 51., 52.,  53.,  54.,  57.,  58.,  59.,  60.,
      63., 64., 65., 66., 69., 70.,  71.,  72.,  87.,  88.,  89.,  90.,
      93., 94., 95., 96., 99., 100., 101., 102., 105., 106., 107., 108.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 1}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<3, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow3Stride1Forward, SAME3x6x6x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      15.,  16.,  17.,  18.,  19.,  20.,  21.,  22.,  23.,  24.,  23.,  24.,
      27.,  28.,  29.,  30.,  31.,  32.,  33.,  34.,  35.,  36.,  35.,  36.,
      39.,  40.,  41.,  42.,  43.,  44.,  45.,  46.,  47.,  48.,  47.,  48.,
      51.,  52.,  53.,  54.,  55.,  56.,  57.,  58.,  59.,  60.,  59.,  60.,
      63.,  64.,  65.,  66.,  67.,  68.,  69.,  70.,  71.,  72.,  71.,  72.,
      63.,  64.,  65.,  66.,  67.,  68.,  69.,  70.,  71.,  72.,  71.,  72.,
      87.,  88.,  89.,  90.,  91.,  92.,  93.,  94.,  95.,  96.,  95.,  96.,
      99.,  100., 101., 102., 103., 104., 105., 106., 107., 108., 107., 108.,
      111., 112., 113., 114., 115., 116., 117., 118., 119., 120., 119., 120.,
      123., 124., 125., 126., 127., 128., 129., 130., 131., 132., 131., 132.,
      135., 136., 137., 138., 139., 140., 141., 142., 143., 144., 143., 144.,
      135., 136., 137., 138., 139., 140., 141., 142., 143., 144., 143., 144.,
      159., 160., 161., 162., 163., 164., 165., 166., 167., 168., 167., 168.,
      171., 172., 173., 174., 175., 176., 177., 178., 179., 180., 179., 180.,
      183., 184., 185., 186., 187., 188., 189., 190., 191., 192., 191., 192.,
      195., 196., 197., 198., 199., 200., 201., 202., 203., 204., 203., 204.,
      207., 208., 209., 210., 211., 212., 213., 214., 215., 216., 215., 216.,
      207., 208., 209., 210., 211., 212., 213., 214., 215., 216., 215., 216.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 2}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<3, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow3Stride1Forward, VALID3x6x6x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      29.,  30.,  31.,  32.,  33.,  34.,  35.,  36.,  41.,  42.,  43.,  44.,
      45.,  46.,  47.,  48.,  53.,  54.,  55.,  56.,  57.,  58.,  59.,  60.,
      65.,  66.,  67.,  68.,  69.,  70.,  71.,  72.,  101., 102., 103., 104.,
      105., 106., 107., 108., 113., 114., 115., 116., 117., 118., 119., 120.,
      125., 126., 127., 128., 129., 130., 131., 132., 137., 138., 139., 140.,
      141., 142., 143., 144., 173., 174., 175., 176., 177., 178., 179., 180.,
      185., 186., 187., 188., 189., 190., 191., 192., 197., 198., 199., 200.,
      201., 202., 203., 204., 209., 210., 211., 212., 213., 214., 215., 216.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 2}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<3, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow3Stride1Forward, SAME3x6x6x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      29.,  30.,  31.,  32.,  33.,  34.,  35.,  36.,  37.,  38.,  39.,  40.,
      41.,  42.,  43.,  44.,  45.,  46.,  47.,  48.,  45.,  46.,  47.,  48.,
      53.,  54.,  55.,  56.,  57.,  58.,  59.,  60.,  61.,  62.,  63.,  64.,
      65.,  66.,  67.,  68.,  69.,  70.,  71.,  72.,  69.,  70.,  71.,  72.,
      77.,  78.,  79.,  80.,  81.,  82.,  83.,  84.,  85.,  86.,  87.,  88.,
      89.,  90.,  91.,  92.,  93.,  94.,  95.,  96.,  93.,  94.,  95.,  96.,
      101., 102., 103., 104., 105., 106., 107., 108., 109., 110., 111., 112.,
      113., 114., 115., 116., 117., 118., 119., 120., 117., 118., 119., 120.,
      125., 126., 127., 128., 129., 130., 131., 132., 133., 134., 135., 136.,
      137., 138., 139., 140., 141., 142., 143., 144., 141., 142., 143., 144.,
      125., 126., 127., 128., 129., 130., 131., 132., 133., 134., 135., 136.,
      137., 138., 139., 140., 141., 142., 143., 144., 141., 142., 143., 144.,
      173., 174., 175., 176., 177., 178., 179., 180., 181., 182., 183., 184.,
      185., 186., 187., 188., 189., 190., 191., 192., 189., 190., 191., 192.,
      197., 198., 199., 200., 201., 202., 203., 204., 205., 206., 207., 208.,
      209., 210., 211., 212., 213., 214., 215., 216., 213., 214., 215., 216.,
      221., 222., 223., 224., 225., 226., 227., 228., 229., 230., 231., 232.,
      233., 234., 235., 236., 237., 238., 239., 240., 237., 238., 239., 240.,
      245., 246., 247., 248., 249., 250., 251., 252., 253., 254., 255., 256.,
      257., 258., 259., 260., 261., 262., 263., 264., 261., 262., 263., 264.,
      269., 270., 271., 272., 273., 274., 275., 276., 277., 278., 279., 280.,
      281., 282., 283., 284., 285., 286., 287., 288., 285., 286., 287., 288.,
      269., 270., 271., 272., 273., 274., 275., 276., 277., 278., 279., 280.,
      281., 282., 283., 284., 285., 286., 287., 288., 285., 286., 287., 288.,
      317., 318., 319., 320., 321., 322., 323., 324., 325., 326., 327., 328.,
      329., 330., 331., 332., 333., 334., 335., 336., 333., 334., 335., 336.,
      341., 342., 343., 344., 345., 346., 347., 348., 349., 350., 351., 352.,
      353., 354., 355., 356., 357., 358., 359., 360., 357., 358., 359., 360.,
      365., 366., 367., 368., 369., 370., 371., 372., 373., 374., 375., 376.,
      377., 378., 379., 380., 381., 382., 383., 384., 381., 382., 383., 384.,
      389., 390., 391., 392., 393., 394., 395., 396., 397., 398., 399., 400.,
      401., 402., 403., 404., 405., 406., 407., 408., 405., 406., 407., 408.,
      413., 414., 415., 416., 417., 418., 419., 420., 421., 422., 423., 424.,
      425., 426., 427., 428., 429., 430., 431., 432., 429., 430., 431., 432.,
      413., 414., 415., 416., 417., 418., 419., 420., 421., 422., 423., 424.,
      425., 426., 427., 428., 429., 430., 431., 432., 429., 430., 431., 432.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 4}};
  const auto padding = PaddingMode::SAME;
  const auto params = getPoolingParams<3, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
TYPED_TEST(MaxWindow3Stride1Forward, VALID3x6x6x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      57.,  58.,  59.,  60.,  61.,  62.,  63.,  64.,  65.,  66.,  67.,  68.,
      69.,  70.,  71.,  72.,  81.,  82.,  83.,  84.,  85.,  86.,  87.,  88.,
      89.,  90.,  91.,  92.,  93.,  94.,  95.,  96.,  105., 106., 107., 108.,
      109., 110., 111., 112., 113., 114., 115., 116., 117., 118., 119., 120.,
      129., 130., 131., 132., 133., 134., 135., 136., 137., 138., 139., 140.,
      141., 142., 143., 144., 201., 202., 203., 204., 205., 206., 207., 208.,
      209., 210., 211., 212., 213., 214., 215., 216., 225., 226., 227., 228.,
      229., 230., 231., 232., 233., 234., 235., 236., 237., 238., 239., 240.,
      249., 250., 251., 252., 253., 254., 255., 256., 257., 258., 259., 260.,
      261., 262., 263., 264., 273., 274., 275., 276., 277., 278., 279., 280.,
      281., 282., 283., 284., 285., 286., 287., 288., 345., 346., 347., 348.,
      349., 350., 351., 352., 353., 354., 355., 356., 357., 358., 359., 360.,
      369., 370., 371., 372., 373., 374., 375., 376., 377., 378., 379., 380.,
      381., 382., 383., 384., 393., 394., 395., 396., 397., 398., 399., 400.,
      401., 402., 403., 404., 405., 406., 407., 408., 417., 418., 419., 420.,
      421., 422., 423., 424., 425., 426., 427., 428., 429., 430., 431., 432.};
  const std::array<int, 4> in_shape = {{3, 6, 6, 4}};
  const auto padding = PaddingMode::VALID;
  const auto params = getPoolingParams<3, 1>(in_shape, padding);
  const DataType max_input_val = 2048.0;
  this->test_pool(exp_out, params, max_input_val);
}
